{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8f6c4aa7",
   "metadata": {},
   "source": [
    "# HW4-Lab1 - Transformer应用 - Math Word Problem\n",
    "\n",
    "## 0. 任务介绍\n",
    "\n",
    "### 0.1 问题背景\n",
    "\n",
    "MWP模型的输入是一段数学文本，输出是求解该问题的方程，如下图所示\n",
    "\n",
    "<img src=\"./pic/problem.png\" width=\"60%\" />\n",
    "\n",
    "输入的数学文本是一个序列（单词级别分词），输出的方程也是一个序列（字符级别分词），下图展示了一个最简单的MWP模型：\n",
    "\n",
    "<img src=\"./pic/model.png\" width=\"100%\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f3ff9f7",
   "metadata": {},
   "source": [
    "### 0.2 任务说明\n",
    "\n",
    "以下代码给出了基于 RNN 的 MWP 模型[1]的实现，包括数据处理、模型构建、训练和预测等部分，准确率在 5.4% 左右。\n",
    "\n",
    "请以给出的代码模板作为参考，使用 Transformer 进行改进， 要求：\n",
    "- 在 30 个 epoch 内\n",
    "- 测试集上的准确率达到 20% 以上\n",
    "\n",
    "### 0.3 Hint\n",
    "\n",
    "一个推荐的 Transformer 超参数如下：\n",
    "\n",
    "- num_layers: 4\n",
    "- embedding_dim: 128\n",
    "- num_heads: 8\n",
    "- ffn_dim: 512\n",
    "- dropout: 0.1\n",
    "- learning_rate: 0.0008\n",
    "\n",
    "其中学习率可能需要个性化调整。\n",
    "\n",
    "\n",
    "\n",
    "[1] Wang, Yan et al. “Deep Neural Solver for Math Word Problems.” Conference on Empirical Methods in Natural Language Processing (2017)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3043cb0d",
   "metadata": {},
   "source": [
    "## 1. 数据集准备\n",
    "\n",
    "我们使用 [Math23K](https://paperswithcode.com/dataset/math23k) 数据集，其中包含数学应用题以及对应的方程。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4d99d358",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import math\n",
    "\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch import Tensor\n",
    "from torch.utils.data import Dataset\n",
    "\n",
    "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "PAD_IDX = 1\n",
    "\n",
    "# Set seed.\n",
    "seed = 42\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)\n",
    "torch.cuda.manual_seed(seed)\n",
    "torch.backends.cudnn.deterministic = True\n",
    "torch.backends.cudnn.benchmark = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c5abc787",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集大小: 22162\n",
      "测试集大小: 1000\n"
     ]
    }
   ],
   "source": [
    "# 读取Math23K数据集\n",
    "def read_math23k_data(path):\n",
    "    with open(path, \"r\", encoding=\"utf-8\") as f:\n",
    "        data = json.load(f)\n",
    "    problems = [item[\"text\"].split() for item in data]  # 将问题文本分割成单词\n",
    "    equations = [item[\"target_template\"][2:] for item in data]  # 移除方程的 'x=' 前缀\n",
    "    return problems, equations\n",
    "\n",
    "\n",
    "train_path, test_path = \"data/train.json\", \"data/test.json\"\n",
    "# 加载数据集\n",
    "train_problems, train_equations = read_math23k_data(\"data/train.json\")\n",
    "test_problems, test_equations = read_math23k_data(\"data/test.json\")\n",
    "\n",
    "print(f\"训练集大小: {len(train_problems)}\")\n",
    "print(f\"测试集大小: {len(test_problems)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "850398ad",
   "metadata": {},
   "source": [
    "让我们看一下数据集中的示例。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4c2b370e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "问题 1: ['甲数', '除以', '乙数', '的', '商是', 'temp_a', '，', '如果', '甲数', '增加', 'temp_b', '，', '则', '甲数', '是', '乙', '的', 'temp_c', '倍', '．', '原来', '甲数', '=', '．']\n",
      "方程 1: ['temp_b', '/', '(', 'temp_c', '-', 'temp_a', ')', '*', 'temp_a']\n",
      "--------------------\n",
      "问题 2: ['客车', '和', '货车', '分别', '从', 'A', '、', 'B', '两站', '同时', '相向', '开出', '，', 'temp_a', '小时', '后', '相遇', '．', '相遇', '后', '，', '两车', '仍', '按原', '速度', '前进', '，', '当', '它们', '相距', 'temp_b', '千米', '时', '，', '货车', '行', '了', '全程', '的', 'temp_c', '%', '，', '客车', '已行', '的', '路程', '与', '未行', '的', '路程', '比是', 'temp_d', '：', 'temp_e', '．', '求', 'A', '、', 'B', '两站', '间', '的', '路程', '．']\n",
      "方程 2: ['temp_b', '/', '(', 'temp_c', '+', '(', '(', 'temp_d', ')', '/', '(', 'temp_d', '+', 'temp_e', ')', ')', '-', '1', ')']\n",
      "--------------------\n",
      "问题 3: ['图书', '角有', '书', 'temp_a', '本', '，', '第一天', '借出', '了', 'temp_b', '，', '第二天', '又', '还', '回', 'temp_c', '本', '，', '现在', '图书', '角有', '多少', '本书', '？']\n",
      "方程 3: ['temp_a', '*', '(', '1', '-', 'temp_b', ')', '+', 'temp_c']\n",
      "--------------------\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    print(f\"问题 {i+1}: {train_problems[i]}\")\n",
    "    print(f\"方程 {i+1}: {train_equations[i]}\")\n",
    "    print(\"-\" * 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "796b984f",
   "metadata": {},
   "source": [
    "## 2. 数据预处理\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f903676",
   "metadata": {},
   "source": [
    "### 2.1 创建词汇表\n",
    "\n",
    "我们将构建一个 Vocab 类，将每个 token 映射到一个唯一的整数 ID，并定义反向的映射。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "57bb4cea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Source Vocab Size: 15452\n",
      "Target Vocab Size: 30\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "\n",
    "class Vocab:\n",
    "    def __init__(self, sentence_list, min_count=1):\n",
    "        self.token2idx = {\"<unk>\": 0, \"<pad>\": 1, \"<bos>\": 2, \"<eos>\": 3}\n",
    "        self.build_vocab(sentence_list, min_count)\n",
    "\n",
    "    def build_vocab(self, sentence_list, min_count):\n",
    "        # 统计词频\n",
    "        token_counts = Counter([token for sentence in sentence_list for token in sentence])\n",
    "        # 对词汇按频率排序并为频率大于等于min_count的词汇分配索引\n",
    "        sorted_tokens = [token for token, count in token_counts.items() if count >= min_count]\n",
    "        sorted_tokens.sort(key=lambda token: token_counts[token], reverse=True)\n",
    "        for token in sorted_tokens:\n",
    "            self.token2idx[token] = len(self.token2idx)\n",
    "        # 创建反向索引\n",
    "        self.idx2token = {idx: token for token, idx in self.token2idx.items()}\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.idx2token)\n",
    "\n",
    "    def token_to_index(self, token):\n",
    "        if isinstance(token, str):\n",
    "            return self.token2idx.get(token, self.token2idx[\"<unk>\"])\n",
    "        else:\n",
    "            raise TypeError(\"Token should be a string\")\n",
    "\n",
    "    def index_to_token(self, index):\n",
    "        if isinstance(index, int):\n",
    "            return self.idx2token.get(index, \"<unk>\")\n",
    "        else:\n",
    "            raise TypeError(\"Index should be an integer\")\n",
    "\n",
    "    def to_tokens(self, indices):\n",
    "        return [self.index_to_token(index) for index in indices]\n",
    "\n",
    "    def to_indices(self, tokens):\n",
    "        return [self.token_to_index(token) for token in tokens]\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"Vocab(size={len(self)})\"\n",
    "\n",
    "    def __getitem__(self, tokens):\n",
    "        if not isinstance(tokens, (list, tuple)):\n",
    "            return self.token_to_index(tokens)\n",
    "        return [self.token_to_index(token) for token in tokens]\n",
    "\n",
    "\n",
    "src_vocab = Vocab(train_problems + test_problems)\n",
    "tgt_vocab = Vocab(train_equations + test_equations)\n",
    "print(f\"Source Vocab Size: {len(src_vocab)}\")\n",
    "print(f\"Target Vocab Size: {len(tgt_vocab)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3e185b5",
   "metadata": {},
   "source": [
    "下面我们将使用一些示例数据来演示 Vocab 的用法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "80debfdb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vocab 大小: 12\n",
      "--------------------\n",
      "token 到 index的映射:\n",
      "<unk>: 0\n",
      "<pad>: 1\n",
      "<bos>: 2\n",
      "<eos>: 3\n",
      "学习: 4\n",
      "我: 5\n",
      "爱: 6\n",
      "使: 7\n",
      "快乐: 8\n",
      "深度: 9\n",
      "很: 10\n",
      "有趣: 11\n",
      "--------------------\n",
      "example_tokens[0] 转换为index: [5, 6, 4]\n"
     ]
    }
   ],
   "source": [
    "example_tokens = [[\"我\", \"爱\", \"学习\"], [\"学习\", \"使\", \"我\", \"快乐\"], [\"深度\", \"学习\", \"很\", \"有趣\"]]\n",
    "example_vocab = Vocab(example_tokens)\n",
    "print(f\"vocab 大小: {len(example_vocab)}\")\n",
    "print(\"-\" * 20)\n",
    "print(\"token 到 index的映射:\")\n",
    "for token, idx in example_vocab.token2idx.items():\n",
    "    print(f\"{token}: {idx}\")\n",
    "print(\"-\" * 20)\n",
    "print(f\"example_tokens[0] 转换为index: {example_vocab[example_tokens[0]]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cef535b0",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "### 2.2 生成数据集\n",
    "\n",
    "我们要对数据先进行以下预处理：\n",
    "\n",
    "1. **添加特殊标记（Adding Special Tokens）**：在输入序列的开头和末尾添加特殊标记，如开始标记（`<bos>`）和结束标记（`<eos>`），以及填充标记（`<pad>`）等。这些标记有助于模型更好地理解输入序列的边界和结构。\n",
    "\n",
    "2. **数据向量化（Vectorization）**：将文本数据转换为模型可以处理的数值张量形式。\n",
    "\n",
    "3. **填充和截断（Padding and Truncation）**：RNN 模型对于输入序列的长度通常是固定的，因此需要对输入序列进行填充（padding）或截断（truncation），使得所有序列具有相同的长度。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "08d92e33",
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess_sentence(sentence, vocab, max_len):\n",
    "    # 1. 添加特殊符号\n",
    "    sentence = [\"<bos>\"] + sentence + [\"<eos>\"]\n",
    "    # 2. 将词汇转换为索引\n",
    "    indices = vocab[sentence]\n",
    "    # 3. 将索引转换为张量\n",
    "    indices = torch.tensor(indices)\n",
    "    # 4. 填充PAD\n",
    "    if len(indices) > max_len:\n",
    "        indices = indices[:max_len]\n",
    "    else:\n",
    "        pad_size = max_len - len(indices)\n",
    "        indices = F.pad(indices, (0, pad_size), value=vocab[\"<pad>\"])\n",
    "    return indices\n",
    "\n",
    "\n",
    "class Math23kDataset(Dataset):\n",
    "    def __init__(self, problems, equations, src_vocab, tgt_vocab):\n",
    "        src_max_len, tgt_max_len = 120, 50\n",
    "        src_data = [preprocess_sentence(sentence, src_vocab, src_max_len) for sentence in problems]\n",
    "        tgt_data = [preprocess_sentence(sentence, tgt_vocab, tgt_max_len) for sentence in equations]\n",
    "        self.src_data = torch.stack(src_data).to(DEVICE)\n",
    "        self.tgt_data = torch.stack(tgt_data).to(DEVICE)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.src_data)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        return self.src_data[idx], self.tgt_data[idx]\n",
    "\n",
    "\n",
    "train_dataset = Math23kDataset(train_problems, train_equations, src_vocab, tgt_vocab)\n",
    "test_dataset = Math23kDataset(test_problems, test_equations, src_vocab, tgt_vocab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "44972872",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "src example: tensor([  2, 207, 354, 212,   5, 469,   6,   4,  55, 207, 206,   7,   4, 225,\n",
      "        207,  15,  78,   5,  11,  54,  10,  71, 207,  19,  10,   3,   1,   1,\n",
      "          1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,\n",
      "          1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,\n",
      "          1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,\n",
      "          1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,\n",
      "          1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,\n",
      "          1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,\n",
      "          1,   1,   1,   1,   1,   1,   1,   1], device='cuda:0')\n",
      "src text: <bos> 甲数 除以 乙数 的 商是 temp_a ， 如果 甲数 增加 temp_b ， 则 甲数 是 乙 的 temp_c 倍 ． 原来 甲数 = ． <eos> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad>\n",
      "--------------------\n",
      "tgt example: tensor([ 2,  5,  6,  7, 10, 11,  4,  8,  9,  4,  3,  1,  1,  1,  1,  1,  1,  1,\n",
      "         1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,\n",
      "         1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1],\n",
      "       device='cuda:0')\n",
      "tgt text: <bos> temp_b / ( temp_c - temp_a ) * temp_a <eos> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad>\n"
     ]
    }
   ],
   "source": [
    "src_example, tgt_example = train_dataset[0]\n",
    "print(\"src example:\", src_example)\n",
    "print(\"src text:\", \" \".join(src_vocab.to_tokens(src_example.tolist())))\n",
    "print(\"-\" * 20)\n",
    "print(\"tgt example:\", tgt_example)\n",
    "print(\"tgt text:\", \" \".join(tgt_vocab.to_tokens(tgt_example.tolist())))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7efb821",
   "metadata": {},
   "source": [
    "## 3. 构建基于 RNN 的 MWP模型\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "404e49eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Encoder(nn.Module):\n",
    "    def __init__(self, vocab_size, embed_size, hidden_size=256, num_layers=2, dropout=0.1):\n",
    "        super().__init__()\n",
    "        self.emebdding = nn.Embedding(vocab_size, embed_size, padding_idx=PAD_IDX)\n",
    "        self.rnn = nn.RNN(embed_size, hidden_size, num_layers=num_layers, dropout=dropout, batch_first=True)\n",
    "\n",
    "    def forward(self, encoder_input):\n",
    "        encoder_input = self.emebdding(encoder_input)\n",
    "        _, h_n = self.rnn(encoder_input)\n",
    "        return h_n\n",
    "\n",
    "\n",
    "class Decoder(nn.Module):\n",
    "    def __init__(self, vocab_size, embed_size, hidden_size=256, num_layers=2, dropout=0.1):\n",
    "        super().__init__()\n",
    "        self.embedding = nn.Embedding(vocab_size, embed_size, padding_idx=PAD_IDX)\n",
    "        self.rnn = nn.RNN(\n",
    "            embed_size + hidden_size, hidden_size, num_layers=num_layers, dropout=dropout, batch_first=True\n",
    "        )\n",
    "        self.out = nn.Linear(hidden_size, vocab_size)\n",
    "\n",
    "    def forward(self, encoder_output, decoder_input):\n",
    "        h_n = encoder_output\n",
    "        decoder_input = self.embedding(decoder_input)\n",
    "        context = h_n[-1]  # (batch_size, hidden_size)\n",
    "        context = context.unsqueeze(1).expand(-1, decoder_input.size(1), -1)  # (batch_size, seq_len, hidden_size)\n",
    "        output, h_n = self.rnn(torch.cat((decoder_input, context), -1), h_n)\n",
    "        logits = self.out(output)  # (batch_size, seq_len, vocab_size)\n",
    "        return logits, h_n\n",
    "\n",
    "\n",
    "class Model(nn.Module):\n",
    "    def __init__(self, encoder, decoder):\n",
    "        super().__init__()\n",
    "        self.encoder = encoder\n",
    "        self.decoder = decoder\n",
    "\n",
    "    def forward(self, encoder_input, decoder_input):\n",
    "        return self.decoder(self.encoder(encoder_input), decoder_input)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9e5f2ad",
   "metadata": {},
   "source": [
    "## 4. 训练模型"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49c443b7",
   "metadata": {},
   "source": [
    "### 4.1 定义训练函数和评估函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "5dd62599",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 训练和评估函数\n",
    "def train_epoch(model, train_loader, optimizer, loss_fn):\n",
    "    model.train()\n",
    "    losses = 0\n",
    "    for src, tgt in train_loader:\n",
    "        src, tgt = src.to(DEVICE), tgt.to(DEVICE)\n",
    "        tgt_input = tgt[:, :-1]\n",
    "\n",
    "        logits, _ = model(src, tgt_input)\n",
    "        optimizer.zero_grad()\n",
    "        tgt_out = tgt[:, 1:]\n",
    "        loss = loss_fn(logits.reshape(-1, logits.shape[-1]), tgt_out.reshape(-1))\n",
    "        loss.backward()\n",
    "\n",
    "        torch.nn.utils.clip_grad_norm_(model.parameters(), 1)\n",
    "        optimizer.step()\n",
    "        losses += loss.item()\n",
    "\n",
    "    return losses / len(train_loader)\n",
    "\n",
    "\n",
    "def evaluate(model, val_loader, loss_fn):\n",
    "    model.eval()\n",
    "    losses = 0\n",
    "    for src, tgt in val_loader:\n",
    "        src, tgt = src.to(DEVICE), tgt.to(DEVICE)\n",
    "        tgt_input = tgt[:, :-1]\n",
    "\n",
    "        logits, _ = model(src, tgt_input)\n",
    "\n",
    "        tgt_out = tgt[:, 1:]\n",
    "        loss = loss_fn(logits.reshape(-1, logits.shape[-1]), tgt_out.reshape(-1))\n",
    "        losses += loss.item()\n",
    "\n",
    "    return losses / len(val_loader)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c9b51e1",
   "metadata": {},
   "source": [
    "### 4.2 设置超参数和初始化模型\n",
    "\n",
    "我们将定义模型、优化器和损失函数，并设置训练所需的参数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "32660d5d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total params: 4.562974 M\n"
     ]
    }
   ],
   "source": [
    "# 模型超参数\n",
    "SRC_VOCAB_SIZE = len(src_vocab)\n",
    "TGT_VOCAB_SIZE = len(tgt_vocab)\n",
    "EMB_SIZE = 256\n",
    "\n",
    "BATCH_SIZE = 128\n",
    "LEARNING_RATE = 0.002\n",
    "\n",
    "encoder = Encoder(vocab_size=len(src_vocab), embed_size=EMB_SIZE)\n",
    "decoder = Decoder(vocab_size=len(tgt_vocab), embed_size=EMB_SIZE)\n",
    "model = Model(encoder, decoder)\n",
    "\n",
    "total_params = sum(p.numel() for p in model.parameters())\n",
    "print(\"Total params:\", total_params / 1e6, \"M\")\n",
    "\n",
    "model = model.to(DEVICE)\n",
    "\n",
    "criterion = nn.CrossEntropyLoss(ignore_index=tgt_vocab[\"<pad>\"])\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a31595e5",
   "metadata": {},
   "source": [
    "### 4.3 开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6aea8ebb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, Train loss: 1.128, Val loss: 1.024, Epoch time = 1.914s\n",
      "Epoch: 1, Train loss: 0.999, Val loss: 0.985, Epoch time = 1.812s\n",
      "Epoch: 2, Train loss: 0.971, Val loss: 0.965, Epoch time = 1.811s\n",
      "Epoch: 3, Train loss: 0.953, Val loss: 0.959, Epoch time = 1.811s\n",
      "Epoch: 4, Train loss: 0.944, Val loss: 0.945, Epoch time = 1.813s\n",
      "Epoch: 5, Train loss: 0.934, Val loss: 0.942, Epoch time = 1.815s\n",
      "Epoch: 6, Train loss: 0.928, Val loss: 0.941, Epoch time = 1.813s\n",
      "Epoch: 7, Train loss: 0.922, Val loss: 0.941, Epoch time = 1.814s\n",
      "Epoch: 8, Train loss: 0.920, Val loss: 0.939, Epoch time = 1.812s\n",
      "Epoch: 9, Train loss: 0.915, Val loss: 0.945, Epoch time = 1.813s\n",
      "Epoch: 10, Train loss: 0.911, Val loss: 0.942, Epoch time = 1.813s\n",
      "Epoch: 11, Train loss: 0.909, Val loss: 0.937, Epoch time = 1.814s\n",
      "Epoch: 12, Train loss: 0.907, Val loss: 0.932, Epoch time = 1.812s\n",
      "Epoch: 13, Train loss: 0.905, Val loss: 0.938, Epoch time = 1.812s\n",
      "Epoch: 14, Train loss: 0.904, Val loss: 0.934, Epoch time = 1.812s\n",
      "Epoch: 15, Train loss: 0.905, Val loss: 0.934, Epoch time = 1.812s\n",
      "Epoch: 16, Train loss: 0.903, Val loss: 0.927, Epoch time = 1.813s\n",
      "Epoch: 17, Train loss: 0.898, Val loss: 0.935, Epoch time = 1.813s\n",
      "Epoch: 18, Train loss: 0.897, Val loss: 0.929, Epoch time = 1.813s\n",
      "Epoch: 19, Train loss: 0.897, Val loss: 0.927, Epoch time = 1.813s\n",
      "Epoch: 20, Train loss: 0.895, Val loss: 0.926, Epoch time = 1.813s\n",
      "Epoch: 21, Train loss: 0.893, Val loss: 0.927, Epoch time = 1.813s\n",
      "Epoch: 22, Train loss: 0.894, Val loss: 0.925, Epoch time = 1.813s\n",
      "Epoch: 23, Train loss: 0.892, Val loss: 0.928, Epoch time = 1.812s\n",
      "Epoch: 24, Train loss: 0.893, Val loss: 0.931, Epoch time = 1.813s\n",
      "Epoch: 25, Train loss: 0.893, Val loss: 0.928, Epoch time = 1.813s\n",
      "Epoch: 26, Train loss: 0.893, Val loss: 0.939, Epoch time = 1.812s\n",
      "Epoch: 27, Train loss: 0.896, Val loss: 0.952, Epoch time = 1.812s\n",
      "Epoch: 28, Train loss: 0.897, Val loss: 0.929, Epoch time = 1.814s\n",
      "Epoch: 29, Train loss: 0.892, Val loss: 0.930, Epoch time = 1.812s\n"
     ]
    }
   ],
   "source": [
    "from timeit import default_timer as timer\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "NUM_EPOCHS = 30\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
    "val_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE)\n",
    "\n",
    "train_loss_list, valid_loss_list = [], []\n",
    "\n",
    "for epoch in range(NUM_EPOCHS):\n",
    "    start_time = timer()\n",
    "    train_loss = train_epoch(model, train_loader, optimizer, criterion)\n",
    "    val_loss = evaluate(model, val_loader, criterion)\n",
    "    end_time = timer()\n",
    "    train_loss_list.append(train_loss)\n",
    "    valid_loss_list.append(val_loss)\n",
    "    print(\n",
    "        (\n",
    "            f\"Epoch: {epoch}, Train loss: {train_loss:.3f}, Val loss: {val_loss:.3f}, \"\n",
    "            f\"Epoch time = {(end_time - start_time):.3f}s\"\n",
    "        )\n",
    "    )\n",
    "\n",
    "# 保存模型\n",
    "torch.save(model.state_dict(), \"rnn_model.pth\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "68ec1b91",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 602,
       "width": 855
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%config InlineBackend.figure_format='retina'\n",
    "plt.figure(figsize=(10, 7))\n",
    "plt.plot(train_loss_list, color=\"blue\", linestyle=\"-\", label=\"train loss\")\n",
    "plt.plot(valid_loss_list, color=\"red\", linestyle=\"-\", label=\"valid loss\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a099cfa1",
   "metadata": {},
   "source": [
    "## 5. 模型评估\n",
    "\n",
    "在这一部分，我们将使用测试集上的方程准确率对模型进行评估。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4ed945b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def equation_accuracy(preds, tgts):\n",
    "    correct = 0\n",
    "    for tgt, pred in zip(tgts, preds):\n",
    "        if tgt == pred:\n",
    "            correct += 1\n",
    "    return correct / len(tgts)\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def predict_seq2seq(model, src, max_len, start_symbol):\n",
    "    src = src.to(DEVICE)\n",
    "\n",
    "    pred_seq = [start_symbol]\n",
    "    memory = model.encoder(src)\n",
    "\n",
    "    for i in range(max_len - 1):\n",
    "        y = torch.tensor(pred_seq[-1]).reshape(1, 1).to(DEVICE)  # (batch_size, seq_len)=(1, 1)\n",
    "        out, memory = model.decoder(memory, y)\n",
    "        # out shape: (batch_size, seq_len, tgt_vocab_size)=(1, 1, tgt_vocab_size)\n",
    "        _, next_word = torch.max(out.squeeze(), dim=-1)\n",
    "        next_word = next_word.item()\n",
    "        pred_seq.append(next_word)\n",
    "        if next_word == tgt_vocab[\"<eos>\"]:\n",
    "            break\n",
    "    return pred_seq\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def inference(model, problem):\n",
    "    model.eval()\n",
    "    src = preprocess_sentence(problem, src_vocab, 120)\n",
    "    src = src.unsqueeze(0)\n",
    "    tgt_tokens = predict_seq2seq(model, src, max_len=50, start_symbol=tgt_vocab[\"<bos>\"])\n",
    "    return \"\".join(tgt_vocab.to_tokens(tgt_tokens)).replace(\"<bos>\", \"\").replace(\"<eos>\", \"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "e31fd340",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "问题 1: 在一正方形花池的四周栽了temp_a棵柳树，每两棵柳树之间的间隔是temp_b米，这个正方形的周长=多少米？\n",
      "真实方程: temp_a*temp_b\n",
      "预测方程: temp_a*temp_b\n",
      "--------------------\n",
      "问题 2: 张明有temp_a元钱，买书用去temp_b%，买文具的钱是买书的temp_c%．买文具用去多少元？\n",
      "真实方程: temp_a*temp_b*temp_c\n",
      "预测方程: temp_a*temp_b\n",
      "--------------------\n",
      "问题 3: 一个工厂要生产temp_a个零件，前temp_b天生产了temp_c个，剩下的要在temp_d天内完成，平均每天生产多少个？\n",
      "真实方程: (temp_a-temp_c)/temp_d\n",
      "预测方程: temp_a*temp_b\n",
      "--------------------\n",
      "问题 4: 一本字典定价temp_a元，temp_b出售后还赚temp_c%，这本字典进价=多少元．\n",
      "真实方程: temp_a*temp_b/(1+temp_c)\n",
      "预测方程: temp_a*temp_b\n",
      "--------------------\n",
      "问题 5: 修一段长temp_a米的路，前temp_b小时共修了temp_c米，剩下的每小时修temp_d米，还要几小时才能修完？\n",
      "真实方程: (temp_a-temp_c)/temp_d\n",
      "预测方程: temp_a*temp_b\n",
      "--------------------\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    problem, equation = test_problems[i], test_equations[i]\n",
    "    print(f\"问题 {i+1}: {''.join(problem)}\")\n",
    "    print(f\"真实方程: {''.join(equation)}\")\n",
    "    print(f\"预测方程: {inference(model, problem)}\")\n",
    "    print(\"-\" * 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d0dc7ad5",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [00:01<00:00, 883.33it/s]\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "\n",
    "test_loader = DataLoader(test_dataset, batch_size=1)\n",
    "preds, tgts = [], []\n",
    "for src, tgt in tqdm(test_loader):\n",
    "    pred = predict_seq2seq(model, src, max_len=50, start_symbol=tgt_vocab[\"<bos>\"])\n",
    "    pred = tgt_vocab.to_tokens(pred)\n",
    "    preds.append(\"\".join(pred).replace(\"<bos>\", \"\").replace(\"<eos>\", \"\").replace(\"<pad>\", \"\"))\n",
    "    tgts.append(\n",
    "        \"\".join(tgt_vocab.to_tokens(tgt[0].tolist())).replace(\"<bos>\", \"\").replace(\"<eos>\", \"\").replace(\"<pad>\", \"\")\n",
    "    )\n",
    "acc = equation_accuracy(preds, tgts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "68903156",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "方程准确率: 0.054\n"
     ]
    }
   ],
   "source": [
    "print(f\"方程准确率: {acc:.3f}\")"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "-all",
   "main_language": "python",
   "notebook_metadata_filter": "-all"
  },
  "kernelspec": {
   "display_name": "dl",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
